const express = require('express');
const router = express.Router();
const Category=require('../../models/Category')
const Novel=require('../../models/Novel')
const jwt=require('jsonwebtoken')
const multer = require('multer');
const path = require('path');
const mongoose = require('mongoose');
const { v4: uuidv4 } = require('uuid');

// ---------------------- 新增：文章封面 multer 配置 ----------------------
const storage = multer.diskStorage({
  destination: function (req, file, cb) {
    cb(null, 'uploads/covers'); // 存储目录
  },
  filename: function (req, file, cb) {
    // 提取文件扩展名（如 .jpg、.png）
    const ext = path.extname(file.originalname);
    // 生成唯一文件名：uuid + 时间戳 + 扩展名
    const fileName = `${uuidv4()}-${Date.now()}${ext}`;
    cb(null, fileName);
  }
});
const upload = multer({ storage: storage });

const authenticateToken = (req, res, next) => {
  const authHeader = req.headers['authorization']
  const token = authHeader && authHeader.split(' ')[1] // Bearer TOKEN

  if (!token) {
    return res.json({
      code: '2006',
      msg: '访问被拒绝，未提供token',
      data: null
    })
  }

  try {
    const verified = jwt.verify(token, 'my_secret')
    req.user = verified
    next()
  } catch (err) {
    return res.json({
      code: '2007',
      msg: '无效的token',
      data: null
    })
  }
}

router.get('/cate/list', authenticateToken, async (req, res) => {
  try {
    // 从 token 中获取当前用户ID（关联分类的 userId 字段）
    const userId = req.user.id;
    
    // 正确逻辑：查询当前用户的所有分类（按 userId 筛选）
    // find({ userId }) 等价于 find({ userId: userId })
    const categories = await Category.find({ userId }).sort({ _id:1})
      .sort({ createdAt: -1 }) // 按创建时间倒序，最新的在前
      .select('-__v'); // 排除不需要的 __v 字段
    
    // 即使没有分类，也返回空数组（而不是报错），前端可根据空数组做提示
    res.json({
      code: '0000',
      msg: '获取分类列表成功',
      data: categories.map(cate => ({ // 格式化返回字段
        id: cate._id,
        name: cate.name,
        alias: cate.alias,
        // 如需其他字段（如创建时间），可在这里添加
      }))
    });
  } catch (err) {
    res.json({
      code: '2001',
      msg: '获取分类列表失败: ' + err.message,
      data: null
    });
  }
});

// 继续在你的路由文件中添加以下代码
router.post('/cate/add', authenticateToken, async (req, res) => {
  try {
    // 1. 获取请求体参数和当前用户ID
    const { name, alias } = req.body; // 从请求体获取分类名称和别名
    const userId = req.user.id; // 从token中获取当前用户ID

    // 2. 基础参数校验（必填项检查）
    if (!name || !alias) {
      return res.json({
        code: '2002',
        msg: '分类名称和别名不能为空',
        data: null
      });
    }

    // 3. 检查当前用户是否已存在同名或同别名的分类（避免重复）
    // 利用模型的唯一索引（userId + name / userId + alias）做前置检查
    const existingCategory = await Category.findOne({
      $or: [
        { userId, name }, // 同一用户下名称不能重复
        { userId, alias } // 同一用户下别名不能重复
      ]
    });

    if (existingCategory) {
      // 判断是名称重复还是别名重复，返回更具体的提示
      const duplicateField = existingCategory.name === name ? '名称' : '别名';
      return res.json({
        code: '2003',
        msg: `分类${duplicateField}已存在，请更换`,
        data: null
      });
    }

    // 4. 创建并保存新分类
    const newCategory = new Category({
      name,       // 分类名称
      alias,      // 分类别名
      userId      // 关联当前用户（核心：确保数据归属）
    });

    await newCategory.save(); // 保存到数据库

    // 5. 返回成功响应（只返回前端需要的字段）
    res.json({
      code: '0000',
      msg: '分类添加成功',
      data: {
        id: newCategory._id,
        name: newCategory.name,
        alias: newCategory.alias,
        createdAt: newCategory.createdAt // 可选：返回创建时间
      }
    });

  } catch (err) {
    // 捕获数据库异常（如唯一索引冲突的极端情况）
    let errorMsg = '添加分类失败: ' + err.message;
    // 处理唯一索引冲突（虽然前置检查已避免，但防并发场景）
    if (err.code === 11000) {
      errorMsg = '分类名称或别名已存在，请更换';
    }
    res.json({
      code: '2001',
      msg: errorMsg,
      data: null
    });
  }
});

//
router.put('/cate/info', authenticateToken, async (req, res) => {
    try{
        const userId=req.user.id;
        const { id, name, alias }=req.body;

        console.log('编辑分类请求数据:', req.body); // 添加日志

        if(!name || !alias){
            return res.json({
                code:'2002',
                msg:'分类名称和别名不能为空',
                data:null
            })
        }

        const existingCategory = await Category.findOne({
          $or: [
           {userId, name, _id: { $ne: req.body.id }},  // 排除当前编辑的分类
           {userId, alias, _id: { $ne: req.body.id }}  // 排除当前编辑的分类
          ]
        })

        if(existingCategory){
            const duplicateField=existingCategory.name===name ? '名称' : '别名';
            return res.json({
                code:'2003',
                msg:`分类${duplicateField}已存在，请更换`,
                data:null
            })
        }   

        const category=await Category.findOneAndUpdate(
            {userId,_id:req.body.id},   
            {name,alias},
            {new:true}
        )
        if(!category){
            return res.json({
                code:'2004',
                msg:'分类不存在或无权限修改',
                data:null
            })
        }

        console.log('更新结果:', category); // 添加日志

        res.json({
            code:'0000',
            msg:'分类更新成功',
            data:{
                id:category._id,
                name:category.name, 
                alias:category.alias
            }
        })
    }catch(err){
        res.json({
            code:'2001',
            msg:'更新分类失败：'+err.message,
            data:null
        })
    }
});

router.delete('/cate/del', authenticateToken, async (req, res) => {
  try {
    const userId = req.user.id;
    const categoryId = req.query.id; // 从查询参数获取分类ID

    // 步骤1：先校验分类ID格式是否有效（必须在数据库操作前执行）
    if (!mongoose.Types.ObjectId.isValid(categoryId)) {
      return res.json({
        code: '2005',
        msg: '分类ID格式错误',
        data: null
      });
    }

    // 步骤2：执行数据库删除（仅删除当前用户的分类）
    const category = await Category.findOneAndDelete({
      userId, // 确保只能删除自己的分类
      _id: categoryId // 已校验格式，可安全查询
    });

    // 步骤3：判断是否成功删除（若分类不存在或无权限，返回2004）
    if (!category) {
      return res.json({
        code: '2004',
        msg: '分类不存在或无权限删除',
        data: null
      });
    }

    // 步骤4：删除成功，返回正确的成功码
    res.json({
      code: '0000',
      msg: '分类删除成功',
      data: null
    });
  } catch (err) {
    // 仅捕获数据库异常（如网络问题、集合不存在等）
    res.json({
      code: '2001',
      msg: '删除分类失败：' + err.message,
      data: null
    });
  }
});

router.get('/article/list', authenticateToken, async (req, res) => {
  try {
    const userId = req.user.id;
    const categoryId = req.query.categoryId; // 前端传的分类ID
    // 构建查询条件：若有分类ID则筛选，否则查所有
    const queryCondition = { userId };
    if (categoryId && mongoose.Types.ObjectId.isValid(categoryId)) {
      queryCondition.categoryId = categoryId; 
    }
    // 按条件查询
    const novels = await Novel.find(queryCondition)
      .sort({ createdAt: -1 }) // 仅保留一个排序（原代码两个sort，后一个覆盖前一个）
      .select('-__v');
    
    res.json({
      code: '0000',
      msg: '获取小说列表成功',
      data: novels.map(novel => ({
        id: novel._id,
        title: novel.title,
        cate_name: novel.cate_name,
        state: novel.state,
        pub_date: novel.pub_date,
        cover: novel.cover,
        content: novel.content,
        word_count: novel.word_count, // 新增
        chapter_count: novel.chapter_count, // 新增
        last_update: novel.last_update // 新增
      }))
    });
  } catch (err) {
    res.json({ code: '2001', msg: '获取小说列表失败: ' + err.message, data: null });
  }
});

// 获取单本小说详情
router.get('/article/info', authenticateToken, async (req, res) => {
  try {
    const userId = req.user.id;
    const novelId = req.query.id; // 从查询参数获取小说ID

    // 验证小说ID格式
    if (!mongoose.Types.ObjectId.isValid(novelId)) {
      return res.json({
        code: '2005',
        msg: '小说ID格式错误',
        data: null
      });
    }

    // 查询小说详情（确保只能查询自己的小说）
    const novel = await Novel.findOne({ 
      _id: novelId, 
      userId 
    }).select('-__v');

    if (!novel) {
      return res.json({
        code: '2004',
        msg: '小说不存在或无权限查看',
        data: null
      });
    }

    // 处理封面路径（如果是相对路径，转换为完整URL）
    let coverUrl = novel.cover;
    if (coverUrl && !coverUrl.startsWith('http')) {
      const baseUrl = `${req.protocol}://${req.get('host')}`;
      coverUrl = `${baseUrl}/uploads/covers/${novel.cover}`;
    }

    res.json({
      code: '0000',
      msg: '获取小说详情成功',
      data: {
        id: novel._id,
        title: novel.title,
        cate_name: novel.cate_name,
        categoryId: novel.categoryId,
        state: novel.state,
        pub_date: novel.pub_date,
        cover: coverUrl,
        content: novel.content,
        createdAt: novel.createdAt,
        updatedAt: novel.updatedAt,
        word_count: novel.word_count,
        chapter_count: novel.chapter_count,
        last_update: novel.last_update
      }
    });

  } catch (err) {
    res.json({
      code: '2001',
      msg: '获取小说详情失败: ' + err.message,
      data: null
    });
  }
});

// 新增 coverUpload.single('cover') 中间件：处理前端传递的 name="cover" 的文件
router.post('/article/add', upload.single('cover'), authenticateToken, async (req, res) => {
    try {
        console.log('=== 开始处理文章添加请求 ===');
        console.log('请求体:', req.body);
        console.log('上传的文件:', req.file);
        console.log('用户信息:', req.user);
        
        // 确保封面路径正确处理
        let coverPath = '';
        if (req.file) {
            coverPath = req.file.filename; // 使用文件名，不是完整路径
            console.log('封面文件保存成功，文件名:', coverPath);
            console.log('文件保存路径:', req.file.path);
            
            // 验证文件是否实际存在
            const fs = require('fs');
            if (fs.existsSync(req.file.path)) {
                console.log('✅ 封面文件已成功保存到服务器');
            } else {
                console.log('❌ 封面文件保存失败，路径不存在');
            }
        } else {
            console.log('❌ 没有接收到封面文件');
        }
        
        const { title, cate_name, state, pub_date, categoryId, content } = req.body;
        const userId = req.user.id;
        
        // 参数验证
        if (!title || !cate_name || !state || !pub_date || !categoryId) {
            console.log('❌ 参数验证失败');
            return res.json({
                code: '2002',
                msg: '小说标题、分类名称、状态、发布日期和分类ID不能为空',
                data: null
            });
        }
        
        // 创建新文章
        // 在创建小说时初始化字数统计
        const newNovel = new Novel({
          title,
          cate_name,
          categoryId,
          state,
          pub_date: new Date(pub_date),
          cover: coverPath,
          content,
          userId,
          word_count: 0, // 初始化
          chapter_count: 0, // 初始化
          last_update: new Date() // 初始化
        });
        
        const savedNovel = await newNovel.save();
        console.log('✅ 文章保存到数据库成功:', savedNovel._id);
        
        res.json({
            code: '0000',
            msg: '小说添加成功',
            data: {
                id: savedNovel._id,
                title: savedNovel.title,
                cate_name: savedNovel.cate_name,
                state: savedNovel.state,
                pub_date: savedNovel.pub_date,
                cover: savedNovel.cover ? `/uploads/covers/${savedNovel.cover}` : '',
                content: savedNovel.content
            }
        });
        
    } catch (err) {
        console.error('❌ 添加文章失败:', err);
        res.json({
            code: '2001',
            msg: '添加小说失败: ' + err.message,
            data: null
        });
    }
});

// 同样添加 coverUpload.single('cover') 中间件
router.put('/article/info', upload.single('cover'),authenticateToken, async (req, res) => {
  try{
    console.log('=== 编辑文章接口 - 全链路调试日志（绝对路径版）===');
    const userId = req.user.id;
    const { id, title, cate_name, state, pub_date, categoryId, content } = req.body;

    // 1. 检查是否收到前端传递的文件
    console.log('1. 文件接收情况:');
    console.log('   - req.file是否存在:', !!req.file);
    if (req.file) {
      console.log('   - req.file详情:', {
        filename: req.file.filename,
        path: req.file.path,
        mimetype: req.file.mimetype,
        size: req.file.size
      });
    } else {
      console.log('   - 未收到文件（用户未重新上传封面）');
    }

    // 2. 查询旧文章信息
    const oldNovel = await Novel.findOne({ userId, _id: id });
    if (!oldNovel) {
      console.log('2. 数据库查询结果: 未找到用户', userId, '的文章', id);
      return res.json({ code: '2004', msg: '小说不存在或无权限修改', data: null });
    }
    console.log('2. 旧文章信息:');
    console.log('   - 旧封面路径:', oldNovel.cover);
    console.log('   - 文章ID:', oldNovel._id);

    // 3. 处理封面路径 - 直接使用绝对路径
    let coverPath = oldNovel.cover; // 默认复用旧路径（已经是绝对路径）
    
    if (req.file) {
      // 用户重新上传了封面：构建绝对路径
      const baseUrl = `${req.protocol}://${req.get('host')}`;
      coverPath = `${baseUrl}/uploads/covers/${req.file.filename}`;
      console.log('3.1 使用新上传的封面文件，构建绝对路径:', coverPath);
    } else {
      console.log('3.2 复用旧封面绝对路径:', coverPath);
    }

    // 4. 参数校验
    console.log('4. 参数校验:');
    console.log('   - 必填字段是否完整:', !title ? '标题空' : !cate_name ? '分类名空' : !state ? '状态空' : !pub_date ? '日期空' : !categoryId ? '分类ID空' : '完整');
    console.log('   - 分类ID格式是否有效:', mongoose.Types.ObjectId.isValid(categoryId) ? '是' : '否');
    
    if (!title || !cate_name || !state || !pub_date || !categoryId) {
      console.log('   ❌ 参数验证失败');
      return res.json({
        code: '2002',
        msg: '小说标题、分类名称、状态、发布日期和分类ID不能为空',
        data: null
      });
    }

    // 5. 执行数据库更新
    console.log('5. 执行数据库更新:');
    console.log('   - 更新条件:', { userId, _id: id });
    console.log('   - 要更新的字段:', { 
      title, 
      cate_name, 
      state, 
      pub_date: new Date(pub_date), 
      categoryId, 
      cover: coverPath, // 直接存储绝对路径
      content 
    });

    const novel = await Novel.findOneAndUpdate(
      { userId, _id: id },   
      { 
        title, 
        cate_name, 
        state, 
        pub_date: new Date(pub_date), 
        categoryId, 
        cover: coverPath, // 直接存储绝对路径
        content 
      },
      { new: true }
    );

    // 6. 检查更新结果
    if (!novel) {
      console.log('5. 数据库更新结果: 失败（未找到匹配文档，可能权限问题）');
      return res.json({ code: '2004', msg: '小说不存在或无权限修改', data: null });
    }
    console.log('5. 数据库更新结果: 成功');
    console.log('   - 更新后封面路径:', novel.cover);
    console.log('   - 更新后完整文章信息:', novel);

    // 7. 返回响应 - 直接返回数据库中的绝对路径
    console.log('6. 返回前端的封面路径（绝对路径）:', novel.cover);

    res.json({
      code: '0000',
      msg: '小说更新成功',
      data: {
        id: novel._id,
        title: novel.title,
        cate_name: novel.cate_name,
        state: novel.state,
        pub_date: novel.pub_date,
        cover: novel.cover, // 直接返回绝对路径
        content: novel.content
      }
    });

  }catch(err){
    console.error('=== 编辑接口 - 路由内错误 ===', err);
    const errorMsg = err.message.includes('只允许上传图片文件') 
      ? '封面上传失败：只允许上传图片文件' 
      : '更新小说失败：' + err.message;
    res.json({ code: '2001', msg: errorMsg, data: null });
  }
});

router.delete('/article/info', authenticateToken, async (req, res) => {
  try {
    const userId = req.user.id;
    const novelId = req.query.id; // 从查询参数获取小说ID
    if (!mongoose.Types.ObjectId.isValid(novelId)) {
      return res.json({
        code: '2005',
        msg: '小说ID格式错误',
        data: null
      });
    }
    const novel = await Novel.findOneAndDelete({
      userId, // 确保只能删除自己的小说
      _id: novelId // 已校验格式，可安全查询
    });
    if (!novel) {
      return res.json({ 
        code: '2004',
        msg: '小说不存在或无权限删除',
        data: null
      });
    }
    res.json({
      code: '0000',
      msg: '小说删除成功',
      data: null
    });
  } catch (err) {
    res.json({
      code: '2001',
      msg: '删除小说失败：' + err.message,
      data: null
    });
  }
});

module.exports = router;
